Slf4j.js ➔ Slf4j - Code Metrics - ama-team/voxengine-sdk - Measure and Improve Code Quality continuously with Scrutinizer

Slf4j.js ➔ Slf4j B
last analyzed 2017-09-04 02:23 UTC

↳ Parent: lib/logger/Slf4j.js

Complexity

Conditions	3
Paths	4

Size

Total Lines

127

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	3
c	1
b	0
f	0
nc	4
dl	0
loc	127
rs	8.2857
nop	2

13 Functions

Rating	Name	Size	Complexity
A	Slf4j.js ➔ ... ➔ render	10	1
A	Slf4j.js ➔ ... ➔ this.setLevel	4	1
A	Slf4j.js ➔ ... ➔ this.detachAll	5	1
A	Slf4j.js ➔ ... ➔ this.attachAll	1	1
A	Slf4j.js ➔ ... ➔ this.getContext	1	1
A	Slf4j.js ➔ ... ➔ this.detach	1	1
A	Slf4j.js ➔ ... ➔ this.attach	1	1
A	Slf4j.js ➔ ... ➔ this.getName	1	1
A	Slf4j.js ➔ ... ➔ this.getWriter	1	1
A	Slf4j.js ➔ ... ➔ this.setWriter	4	1
A	Slf4j.js ➔ ... ➔ log	19	4
A	Slf4j.js ➔ ... ➔ Level.explicit.forEach	5	1
A	Slf4j.js ➔ ... ➔ this.getLevel	1	1

How to fix Long Method

/**
 * @module logger/slf4j
 */

var Context = require('./_common').Context
var Renderer = require('./Renderer').Renderer
var Level = require('./Level').Level

/**
 * @class Slf4j
 *
 * @param {string} [name] Logger name.
 * @param {Context} [context] Logger context.
 *
 * @implements IVarArgLogger
 */
function Slf4j (name, context) {
  if (!context) {
    context = DefaultContext
  }
  // backward compatibility for 0.1.x/0.2.x
  if (!(context instanceof Context)) {
    context = new Slf4j.Context(context, arguments[2])
  }
  var mdc = {}
  var self = this

  function render (pattern, substitutions) {
    var chunks = pattern.split('{}')
    return substitutions.reduce(function (carrier, entry) {
      if (chunks.length > 0) {
        return carrier + Renderer.any(entry, false) + chunks.shift()
      } else {
        return carrier + '\r\n' + Renderer.any(entry, true)
      }
    }, chunks.shift())
  }

  function log (level, pattern) {
    level = Level.find(level)
    if (level.weight < context.getLevel(name).weight) {
      return
    }
    var prefix = '[' + level.id.toUpperCase() + ']'
    if (name) {
      prefix += ' ' + name
    }
    var mdcPrefix = Object.keys(mdc).map(function (key) {
      return key + '=' + Renderer.any(mdc[key])
    }).join(', ')
    if (mdcPrefix) {
      prefix += ' [' + mdcPrefix + ']'
    }
    var subs = [].slice.call(arguments, 2)
    var writer = context.getWriter(name) || Logger
    writer.write(render(prefix + ': ' + pattern, subs))
  }

  // noinspection JSUnusedGlobalSymbols
  this.log = log

  Level.explicit.forEach(function (level) {
    self[level.id.toLowerCase()] = function () {
      log.apply(null, [level].concat([].slice.call(arguments)))
    }
  })

  this.getName = function () { return name }

  this.setWriter = function (writer) {
    context.setWriter(name, writer)
    return this
  }

  this.getWriter = function () { return context.getWriter(name) }

  this.setLevel = function (level) {
    context.setLevel(name, level)
    return this
  }

  this.getLevel = function () { return context.getLevel(name) }

  /**
   * @deprecated
   */
  this.setThreshold = this.setLevel

  /**
   * @deprecated
   */
  this.getThreshold = this.getLevel

  this.getContext = function () { return context }

  this.attach = function (name, value) { mdc[name] = value }

  this.detach = function (name) { delete mdc[name] }

  this.attachAll = function (values) { mdc = values }

  this.detachAll = function () {
    var b = mdc
    mdc = {}
    return b
  }

  /**
   * @function Slf4j#trace
   * @param {string} pattern Logging pattern with `{}` as a place for substitution
   * @param {...object} parameters List of pattern parameters
   */

  /**
   * @function Slf4j#debug
   * @param {string} pattern Logging pattern with `{}` as a place for substitution
   * @param {...object} parameters List of pattern parameters
   */

  /**
   * @function Slf4j#notice
   * @param {string} pattern Logging pattern with `{}` as a place for substitution
   * @param {...object} parameters List of pattern parameters
   */

  /**
   * @function Slf4j#info
   * @param {string} pattern Logging pattern with `{}` as a place for substitution
   * @param {...object} parameters List of pattern parameters
   */

  /**
   * @function Slf4j#warn
   * @param {string} pattern Logging pattern with `{}` as a place for substitution
   * @param {...object} parameters List of pattern parameters
   */

  /**
   * @function Slf4j#error
   * @param {string} pattern Logging pattern with `{}` as a place for substitution
   * @param {...object} parameters List of pattern parameters
   */
}

/**
 * @class
 * @extends {Context.<Slf4j>}
 */
Slf4j.Context = function () {
  Context.apply(this, arguments)
  var self = this
  /**
   * @param {string} name
   * @param {Level} [threshold]
   * @param {IWritable} [writer]
   * @return {Slf4j}
   */
  this.create = function (name, threshold, writer) {
    if (threshold) {
      self.setLevel(name, threshold)
    }
    if (writer) {
      self.setWriter(name, writer)
    }
    return new Slf4j(name, self)
  }
}
Slf4j.Context.prototype = Object.create(Context.prototype)
Slf4j.Context.constructor = Slf4j.Context

var DefaultContext = new Slf4j.Context()

/**
 * @function Slf4j.create
 * @param {string} name
 * @param {Level} [level]
 * @param {IWritable} [writer]
 * @return {Slf4j}
 */

/**
 * @function Slf4j.getWriter
 * @param {string} name
 * @return {IWritable}
 */

/**
 * @function Slf4j.setWriter
 * @param {string} name
 * @param {IWritable} writer
 * @return {ILoggerContext.<Slf4j>}
 */

/**
 * @function Slf4j.getLevel
 * @param {string} name
 * @return {Level}
 */

/**
 * @function Slf4j.setLevel
 * @param {string} name
 * @param {Level} level
 * @return {ILoggerContext.<Slf4j>}
 */

/**
 * @deprecated
 * @function Slf4j.getThreshold
 * @param {string} name
 * @return {Level}
 */

/**
 * @deprecated
 * @function Slf4j.setThreshold
 * @param {string} name
 * @param {Level} level
 * @return {ILoggerContext.<Slf4j>}
 */
Object.keys(DefaultContext).forEach(function (method) {
  Slf4j[method] = DefaultContext[method].bind(DefaultContext)
})

/**
 * @param {LoggerOptions} [options]
 * @param {String} [name] Default name to use in case options don't include it
 * @param {Context} [context] Default context
 * @param {Level} [level] Default logging level
 * @return {IVarArgLogger}
 */
Slf4j.factory = function (options, name, context, level) {
  options = options || {}
  if (typeof options.log === 'function') {
    // then instance of logger have been passed
    return options
  }
  if (options.instance) {
    return options.instance
  }
  context = options.context || context || Slf4j
  var logger = context.create(options.name || name, level || options.level)
  logger.attachAll(options.mdc || {})
  return logger
}

Slf4j.Level = Level

module.exports = {
  Slf4j: Slf4j,
  /** @deprecated */
  Context: Slf4j.Context,
  /** @deprecated use Slf4j.Level */
  Level: Level
}


1			/**
2			* @module logger/slf4j
3			*/
4
5			var Context = require('./_common').Context
6			var Renderer = require('./Renderer').Renderer
7			var Level = require('./Level').Level
8
9			/**
10			* @class Slf4j
11			*
12			* @param {string} [name] Logger name.
13			* @param {Context} [context] Logger context.
14			*
15			* @implements IVarArgLogger
16			*/
17			function Slf4j (name, context) {
18			if (!context) {
19			context = DefaultContext
20			}
21			// backward compatibility for 0.1.x/0.2.x
22			if (!(context instanceof Context)) {
23			context = new Slf4j.Context(context, arguments[2])
24			}
25			var mdc = {}
26			var self = this
27
28			function render (pattern, substitutions) {
29			var chunks = pattern.split('{}')
30			return substitutions.reduce(function (carrier, entry) {
31			if (chunks.length > 0) {
32			return carrier + Renderer.any(entry, false) + chunks.shift()
33			} else {
34			return carrier + '\r\n' + Renderer.any(entry, true)
35			}
36			}, chunks.shift())
37			}
38
39			function log (level, pattern) {
40			level = Level.find(level)
41			if (level.weight < context.getLevel(name).weight) {
42			return
43			}
44			var prefix = '[' + level.id.toUpperCase() + ']'
45			if (name) {
46			prefix += ' ' + name
47			}
48			var mdcPrefix = Object.keys(mdc).map(function (key) {
49			return key + '=' + Renderer.any(mdc[key])
50			}).join(', ')
51			if (mdcPrefix) {
52			prefix += ' [' + mdcPrefix + ']'
53			}
54			var subs = [].slice.call(arguments, 2)
55			var writer = context.getWriter(name) \|\| Logger
56			writer.write(render(prefix + ': ' + pattern, subs))
57			}
58
59			// noinspection JSUnusedGlobalSymbols
60			this.log = log
61
62			Level.explicit.forEach(function (level) {
63			self[level.id.toLowerCase()] = function () {
64			log.apply(null, [level].concat([].slice.call(arguments)))
65			}
66			})
67
68			this.getName = function () { return name }
69
70			this.setWriter = function (writer) {
71			context.setWriter(name, writer)
72			return this
73			}
74
75			this.getWriter = function () { return context.getWriter(name) }
76
77			this.setLevel = function (level) {
78			context.setLevel(name, level)
79			return this
80			}
81
82			this.getLevel = function () { return context.getLevel(name) }
83
84			/**
85			* @deprecated
86			*/
87			this.setThreshold = this.setLevel
88
89			/**
90			* @deprecated
91			*/
92			this.getThreshold = this.getLevel
93
94			this.getContext = function () { return context }
95
96			this.attach = function (name, value) { mdc[name] = value }
97
98			this.detach = function (name) { delete mdc[name] }
99
100			this.attachAll = function (values) { mdc = values }
101
102			this.detachAll = function () {
103			var b = mdc
104			mdc = {}
105			return b
106			}
107
108			/**
109			* @function Slf4j#trace
110			* @param {string} pattern Logging pattern with `{}` as a place for substitution
111			* @param {...object} parameters List of pattern parameters
112			*/
113
114			/**
115			* @function Slf4j#debug
116			* @param {string} pattern Logging pattern with `{}` as a place for substitution
117			* @param {...object} parameters List of pattern parameters
118			*/
119
120			/**
121			* @function Slf4j#notice
122			* @param {string} pattern Logging pattern with `{}` as a place for substitution
123			* @param {...object} parameters List of pattern parameters
124			*/
125
126			/**
127			* @function Slf4j#info
128			* @param {string} pattern Logging pattern with `{}` as a place for substitution
129			* @param {...object} parameters List of pattern parameters
130			*/
131
132			/**
133			* @function Slf4j#warn
134			* @param {string} pattern Logging pattern with `{}` as a place for substitution
135			* @param {...object} parameters List of pattern parameters
136			*/
137
138			/**
139			* @function Slf4j#error
140			* @param {string} pattern Logging pattern with `{}` as a place for substitution
141			* @param {...object} parameters List of pattern parameters
142			*/
143			}
144
145			/**
146			* @class
147			* @extends {Context.<Slf4j>}
148			*/
149			Slf4j.Context = function () {
150			Context.apply(this, arguments)
151			var self = this
152			/**
153			* @param {string} name
154			* @param {Level} [threshold]
155			* @param {IWritable} [writer]
156			* @return {Slf4j}
157			*/
158			this.create = function (name, threshold, writer) {
159			if (threshold) {
160			self.setLevel(name, threshold)
161			}
162			if (writer) {
163			self.setWriter(name, writer)
164			}
165			return new Slf4j(name, self)
166			}
167			}
168			Slf4j.Context.prototype = Object.create(Context.prototype)
169			Slf4j.Context.constructor = Slf4j.Context
170
171			var DefaultContext = new Slf4j.Context()
172
173			/**
174			* @function Slf4j.create
175			* @param {string} name
176			* @param {Level} [level]
177			* @param {IWritable} [writer]
178			* @return {Slf4j}
179			*/
180
181			/**
182			* @function Slf4j.getWriter
183			* @param {string} name
184			* @return {IWritable}
185			*/
186
187			/**
188			* @function Slf4j.setWriter
189			* @param {string} name
190			* @param {IWritable} writer
191			* @return {ILoggerContext.<Slf4j>}
192			*/
193
194			/**
195			* @function Slf4j.getLevel
196			* @param {string} name
197			* @return {Level}
198			*/
199
200			/**
201			* @function Slf4j.setLevel
202			* @param {string} name
203			* @param {Level} level
204			* @return {ILoggerContext.<Slf4j>}
205			*/
206
207			/**
208			* @deprecated
209			* @function Slf4j.getThreshold
210			* @param {string} name
211			* @return {Level}
212			*/
213
214			/**
215			* @deprecated
216			* @function Slf4j.setThreshold
217			* @param {string} name
218			* @param {Level} level
219			* @return {ILoggerContext.<Slf4j>}
220			*/
221			Object.keys(DefaultContext).forEach(function (method) {
222			Slf4j[method] = DefaultContext[method].bind(DefaultContext)
223			})
224
225			/**
226			* @param {LoggerOptions} [options]
227			* @param {String} [name] Default name to use in case options don't include it
228			* @param {Context} [context] Default context
229			* @param {Level} [level] Default logging level
230			* @return {IVarArgLogger}
231			*/
232			Slf4j.factory = function (options, name, context, level) {
233			options = options \|\| {}
234			if (typeof options.log === 'function') {
235			// then instance of logger have been passed
236			return options
237			}
238			if (options.instance) {
239			return options.instance
240			}
241			context = options.context \|\| context \|\| Slf4j
242			var logger = context.create(options.name \|\| name, level \|\| options.level)
243			logger.attachAll(options.mdc \|\| {})
244			return logger
245			}
246
247			Slf4j.Level = Level
248
249			module.exports = {
250			Slf4j: Slf4j,
251			/** @deprecated */
252			Context: Slf4j.Context,
253			/** @deprecated use Slf4j.Level */
254			Level: Level
255			}
256

ama-team / voxengine-sdk

Slf4j.js ➔ Slf4j B last analyzed 2017-09-04 02:23 UTC

Complexity

Size

Duplication

Importance

13 Functions

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

Slf4j.js ➔ Slf4j B
last analyzed 2017-09-04 02:23 UTC